fix(runtime,hir,codegen): Map/Set mutation during for…of is O(1) per step and never skips an entry - #9513

Summary

#9020 made ordered Map/Set deletes O(1) by tombstoning entries in place and moved the squeeze into the raw-index readers (js_map_entry_key_at / js_set_value_at) as a "self-heal": the first raw read that observed a hole compacted the whole collection. The for…of fast path reads raw slots on every step, so a loop that deletes while iterating paid one full compaction per delete — 50,000 entries with 12,500 deletes inside the walk took 13–32 s against node's 0.07 s (quadratic in n), while the identical deletes with no iterator open cost 0.5 s.

It was also a correctness bug. Every raw-index cursor (the fast path and the iterator objects) recovered from a squeeze by re-finding the last returned key and, when that key was itself deleted, reading cursor-1 — which assumes exactly ONE hole was squeezed. Deleting several already-visited entries plus the current one in a single body skipped entries, and enough holes ended the loop early:

const m = new Map(); for (let i = 0; i < 40; i++) m.set("k" + i, i);
const seen = [];
for (const [k] of m) { seen.push(k); if (k === "k20") for (let i = 0; i <= 20; i++) m.delete("k" + i); }
// node: 40 entries visited        perry (main): stops at k20 — 19 entries never visited

Map and Set, both walkers.

Fix

The way V8 transitions ordered-hash-table iterators. Every squeeze (compact_*, and clear while a walk may be open) records the raw indices it removed in a per-collection log and bumps a compaction_epoch in the header (offset 36 for MapHeader, 28 for SetHeader — both in existing padding, so no other offset moves and the codegen-pinned used offset test still passes). A cursor carries the epoch it last synchronised with; one call per step (js_map_cursor_next / js_set_cursor_next) rebases it — down by exactly the removed count below it, in order, through every record since — then steps over tombstones and returns the next live raw index.

This is exact by the walk's own invariant (the yielded entries are precisely the live entries below the cursor), needs no key lookup, and no "iteration active" registration that a break, return or abandoned generator could leak. The readers no longer compact at all; the codegen inline entry read is bounded by the raw extent instead of requiring a dense buffer; the iterator objects keep the epoch in their former size-sentinel field 3. clear() inside a walk is recorded as a prefix squeeze, so the cursor restarts at 0 and sees later appends, as the spec's in-place emptying of [[MapData]] requires. Log depth is bounded at 32 records per collection (a cursor that old is stepped over holes without rebase; reaching it needs one loop body to force 32 squeezes of the same collection).

Numbers

Quiet host (Node 26.5.1), warm, 50,000 entries / 12,500 mutations inside the walk:

Every during-iteration variant now costs the same as its no-iterator control.

Tests / validation

• Runtime unit tests: the no-compaction read contract, the exact multi-hole rebase, successive squeezes + clear, address reuse — Map and Set. The one test that pinned the old self-heal (raw_indexed_access_self_heals_by_compacting) is rewritten to pin the new contract; map::tests::ordered_delete_repairs_mixed_side_indexes_and_preserves_order walks live entries through the cursor instead of assuming raw == live.
• test-files/test_gap_map_set_multi_delete_during_iteration.ts: fast path, iterator objects, re-add, clear, 1/3/21-hole Map+Set, and a 50k churn — node-differential.
• RUST_TEST_THREADS=1 cargo test --release -p perry-runtime: 2979 passed, 0 failed. perry-hir / perry-codegen suites green. cargo clippy --workspace: 0 warnings. scripts/run_lint_gates.sh: 60/60 (the two new perry_thread_local! holders are classified in gc_runtime_root_holders.json).
• GC arms over the new fixture — PERRY_GC_FORCE_EVACUATE=1 PERRY_GC_VERIFY_EVACUATION=1, PERRY_GC_SCHEDULE_SEED=1, from-space protect (depth 800), PERRY_GC_VERIFY_MARK=1 — all match node (the log side table is re-keyed by map_header_moved_for_gc / set_header_moved_for_gc and pruned by the dead-owner sweep).
• Every Map/Set/for-of/iterator fixture under test-files/ re-run against node: 87/87 relevant match.

Not changed: forEach's "suppress compaction while active" registration (correct, unwinding already wired through the exception savepoints; could adopt the same rebase later), and the js_map_entries/keys/values materialisers, which still compact first and are O(n) by nature.

Summary by CodeRabbit

• Bug Fixes
  • Fixed Map and Set iteration when entries are deleted, re-added, or cleared during traversal.
  • Iteration now preserves insertion order, visits each eligible entry once, and avoids prematurely ending or skipping loops.
  • Improved performance for large mutation-heavy iterations by preventing repeated compaction.
  • Added support for reliable iteration across internal collection changes and garbage collection.